// 蓝牙管理工具类
class BleManager {
  constructor() {
    this.deviceId = null;
    this.targetServiceId = '0783b03e-8535-b5a0-7140-a304f013c3b7';  // 预定义的目标服务ID
    this.serviceId = null;     // 实际使用的服务ID
    this.notifyCharId = null;  // 初始化为 null，等待从设备获取
    this.writeCharId = null;   // 初始化为 null，等待从设备获取
    this.targetDeviceName = '';
    this.targetDeviceId = '';
    this.connectionStateCallback = null;
    this.isConnected = false;
    this.isSearching = false;
    this.batteryUpdateCallback = null;
    this.searchTimeout = null;  // 搜索超时定时器
    this.searchTimeoutDuration = 60000;  // 搜索超时时间，默认60秒
  }

  // 初始化蓝牙适配器
  initBle() {
    return new Promise((resolve, reject) => {
      wx.openBluetoothAdapter({
        success: (res) => {
          console.log('蓝牙适配器初始化成功');
          // 监听蓝牙连接状态变化
          this.startMonitorConnection();
          resolve(res);
        },
        fail: (err) => {
          console.error('蓝牙适配器初始化失败', err);
          if (err.errCode === 10000) {
            console.error('错误原因：未初始化蓝牙适配器');
          } else if (err.errCode === 10001) {
            console.error('错误原因：当前蓝牙适配器不可用');
          } else if (err.errCode === 10009) {
            console.error('错误原因：系统版本低于 4.3 不支持 BLE');
          }
          reject(err);
        }
      });
    });
  }

  // 开始监听蓝牙连接状态
  startMonitorConnection() {
    wx.onBLEConnectionStateChange((res) => {
      console.log('蓝牙连接状态变化:', res);
      const isConnected = res.connected;
      
      if (!isConnected) {
        // 设备断开连接
        console.log('设备断开连接');
        this.cleanup();
      }
      
      // 通知连接状态变化
      if (this.connectionStateCallback) {
        this.connectionStateCallback(isConnected);
      }
    });
  }

  // 设置连接状态变化回调
  onConnectionStateChange(callback) {
    this.connectionStateCallback = callback;
  }

  // 设置目标设备信息
  setTargetDevice(deviceName, deviceId) {
    this.targetDeviceName = deviceName;
    this.targetDeviceId = deviceId;
    console.log('设置目标设备:', deviceName, deviceId);
  }

  // 设置搜索超时时间
  setSearchTimeout(duration) {
    this.searchTimeoutDuration = duration;
    console.log('设置搜索超时时间:', duration, 'ms');
  }

  // 开始搜索设备
  startSearch() {
    return new Promise((resolve, reject) => {
      if (!this.targetDeviceName || !this.targetDeviceId) {
        reject(new Error('请先设置目标设备信息'));
        return;
      }

      if (this.isSearching) {
        reject(new Error('正在搜索中'));
        return;
      }

      this.isSearching = true;
      console.log('开始搜索设备...');

      // 设置搜索超时
      this.searchTimeout = setTimeout(() => {
        if (this.isSearching) {
          console.log('搜索超时，停止搜索');
          this.stopSearch().then(() => {
            reject(new Error('搜索超时，未找到目标设备'));
          });
        }
      }, this.searchTimeoutDuration);  // 使用配置的超时时间

      // 先停止之前的搜索
      wx.stopBluetoothDevicesDiscovery({
        complete: () => {
          // 开始新的搜索
          wx.startBluetoothDevicesDiscovery({
            allowDuplicatesKey: false,
            success: (res) => {
              console.log('开始搜索成功');
              this._onDeviceFound(resolve, reject);
            },
            fail: (err) => {
              console.error('开始搜索失败:', err);
              this.isSearching = false;
              clearTimeout(this.searchTimeout);  // 清除超时定时器
              reject(err);
            }
          });
        },
        fail: (err) => {
          console.error('停止搜索失败:', err);
          this.isSearching = false;
          clearTimeout(this.searchTimeout);  // 清除超时定时器
          reject(err);
        }
      });
    });
  }

  // 设备发现回调
  _onDeviceFound(resolve, reject) {
    wx.onBluetoothDeviceFound((res) => {
      const devices = res.devices;
      console.log('发现设备:', devices);
      
      // 打印所有发现的设备信息
      devices.forEach(device => {
        console.log('设备名称:', device.name, '设备ID:', device.deviceId);
      });
      
      // 查找目标设备
      const targetDevice = devices.find(device => {
        const nameMatch = device.name === this.targetDeviceName;
        const idMatch = device.deviceId === this.targetDeviceId;
        console.log('设备匹配结果:', {
          deviceName: device.name,
          deviceId: device.deviceId,
          nameMatch,
          idMatch
        });
        return nameMatch || idMatch;
      });

      if (targetDevice) {
        console.log('找到目标设备:', targetDevice);
        // 清除超时定时器
        if (this.searchTimeout) {
          clearTimeout(this.searchTimeout);
          this.searchTimeout = null;
        }
        this.stopSearch().then(() => {
          this.deviceId = targetDevice.deviceId;
          this.connectDevice().then(resolve).catch(reject);
        });
      }
    });
  }

  // 连接设备
  connectDevice() {
    return new Promise((resolve, reject) => {
      console.log('开始连接设备:', this.deviceId);
      
      wx.createBLEConnection({
        deviceId: this.deviceId,
        success: (res) => {
          console.log('连接设备成功');
          this.isConnected = true;
          this.getServices().then(resolve).catch(reject);
        },
        fail: (err) => {
          console.error('连接设备失败:', err);
          this.isConnected = false;
          reject(err);
        }
      });
    });
  }

  // 获取服务
  getServices() {
    return new Promise((resolve, reject) => {
      console.log('开始获取服务...');
      
      wx.getBLEDeviceServices({
        deviceId: this.deviceId,
        success: (res) => {
          console.log('获取服务成功:', res.services);
          const services = res.services;
          
          // 打印所有服务信息
          services.forEach(service => {
            console.log('服务UUID:', service.uuid);
          });

          // 查找目标服务
          const targetService = services.find(service => 
            service.uuid.toLowerCase() === this.targetServiceId.toLowerCase()
          );

          if (targetService) {
            console.log('找到目标服务:', targetService.uuid);
            this.serviceId = targetService.uuid;  // 使用实际找到的服务ID
            this.getCharacteristics().then(resolve).catch(reject);
          } else {
            console.error('未找到目标服务');
            console.log('可用服务列表:', services.map(s => s.uuid));
            this.disconnect().then(() => {
              reject(new Error('未找到目标服务'));
            });
          }
        },
        fail: (err) => {
          console.error('获取服务失败:', err);
          reject(err);
        }
      });
    });
  }

  // 获取特征值
  getCharacteristics() {
    return new Promise((resolve, reject) => {
      console.log('开始获取特征值...');
      console.log('设备ID:', this.deviceId);
      console.log('服务ID:', this.serviceId);
      
      wx.getBLEDeviceCharacteristics({
        deviceId: this.deviceId,
        serviceId: this.serviceId,
        success: (res) => {
          console.log('获取特征值成功:', res.characteristics);
          const characteristics = res.characteristics;
          
          // 打印所有特征值信息
          characteristics.forEach(char => {
            console.log('特征值UUID:', char.uuid);
            console.log('特征值属性:', {
              read: char.properties.read ? '可读' : '不可读',
              write: char.properties.write ? '可写' : '不可写',
              notify: char.properties.notify ? '可通知' : '不可通知',
              indicate: char.properties.indicate ? '可指示' : '不可指示'
            });
          });
          
          // 查找通知特征值
          const notifyChar = characteristics.find(char => 
            char.properties.notify || char.properties.indicate
          );

          // 查找写入特征值
          const writeChar = characteristics.find(char => 
            char.properties.write || char.properties.writeWithoutResponse
          );

          if (notifyChar && writeChar) {
            console.log('找到通知特征值:', notifyChar.uuid);
            console.log('找到写入特征值:', writeChar.uuid);
            this.notifyCharId = notifyChar.uuid;
            this.writeCharId = writeChar.uuid;
            this.enableNotify().then(resolve).catch(reject);
          } else {
            console.error('未找到所需的特征值');
            console.error('可用特征值列表:', characteristics.map(c => ({
              uuid: c.uuid,
              properties: c.properties
            })));
            this.disconnect().then(() => {
              reject(new Error('未找到所需的特征值'));
            });
          }
        },
        fail: (err) => {
          console.error('获取特征值失败:', err);
          if (err.errCode === 10000) {
            console.error('错误原因：未初始化蓝牙适配器');
          } else if (err.errCode === 10001) {
            console.error('错误原因：当前蓝牙适配器不可用');
          } else if (err.errCode === 10002) {
            console.error('错误原因：没有找到指定设备');
          } else if (err.errCode === 10006) {
            console.error('错误原因：当前连接已断开');
          } else if (err.errCode === 10004) {
            console.error('错误原因：没有找到指定服务');
          } else if (err.errCode === 10013) {
            console.error('错误原因：连接 deviceId 为空或者是格式不正确');
          }
          reject(err);
        }
      });
    });
  }

  // 启用通知
  enableNotify() {
    return new Promise((resolve, reject) => {
      console.log('启用通知入参:', {
        deviceId: this.deviceId,
        serviceId: this.serviceId,
        characteristicId: this.notifyCharId,
        state: true
      });

      wx.notifyBLECharacteristicValueChange({
        deviceId: this.deviceId,
        serviceId: this.serviceId,
        characteristicId: this.notifyCharId,
        state: true,
        success: (res) => {
          console.log('启用通知成功');
          this._onCharacteristicValueChange();
          resolve(res);
        },
        fail: (err) => {
          console.error('启用通知失败', err);
          if (err.errCode === 10000) {
            console.error('错误原因：未初始化蓝牙适配器');
          } else if (err.errCode === 10001) {
            console.error('错误原因：当前蓝牙适配器不可用');
          } else if (err.errCode === 10002) {
            console.error('错误原因：没有找到指定设备');
          } else if (err.errCode === 10006) {
            console.error('错误原因：当前连接已断开');
          } else if (err.errCode === 10004) {
            console.error('错误原因：没有找到指定服务');
          } else if (err.errCode === 10005) {
            console.error('错误原因：没有找到指定特征');
          } else if (err.errCode === 10007) {
            console.error('错误原因：当前特征不支持此操作');
          } else if (err.errCode === 10013) {
            console.error('错误原因：连接 deviceId 为空或者是格式不正确');
          }
          reject(err);
        }
      });
    });
  }

  // 监听特征值变化
  _onCharacteristicValueChange() {
    wx.onBLECharacteristicValueChange((res) => {
      console.log('特征值变化:', res);
      const value = res.value;
      const dataView = new DataView(value);
      let result = '';
      for (let i = 0; i < dataView.byteLength; i++) {
        result += String.fromCharCode(dataView.getUint8(i));
      }
      console.log('接收到的数据:', result);
      
      // 解析通知内容
      if (result.startsWith('AT+STATE:')) {
        try {
          // 提取状态部分
          const statePart = result.split(';')[0];
          const values = statePart.split(':')[1].split(',');
          
          // 解析电量百分比和电压
          const batteryPercent = parseInt(values[1]);
          const voltage = parseInt(values[2]);
          
          console.log('电量百分比:', batteryPercent, '%');
          console.log('电压:', voltage, 'mV');
          
          // 触发电量更新事件
          const event = {
            batteryPercent,
            voltage
          };
          this.emitBatteryUpdate(event);
        } catch (error) {
          console.error('解析通知内容失败:', error);
        }
      }
    });
  }

  // 添加电量更新事件监听器
  onBatteryUpdate(callback) {
    this.batteryUpdateCallback = callback;
  }

  // 触发电量更新事件
  emitBatteryUpdate(event) {
    if (this.batteryUpdateCallback) {
      this.batteryUpdateCallback(event);
    }
  }

  // 发送指令
  sendCommand(command) {
    return new Promise((resolve, reject) => {
      if (!this.isConnected) {
        reject(new Error('设备未连接'));
        return;
      }

      const buffer = new ArrayBuffer(command.length);
      const dataView = new DataView(buffer);
      for (let i = 0; i < command.length; i++) {
        dataView.setUint8(i, command.charCodeAt(i));
      }

      wx.writeBLECharacteristicValue({
        deviceId: this.deviceId,
        serviceId: this.serviceId,
        characteristicId: this.writeCharId,
        value: buffer,
        success: () => {
          console.log('发送指令成功:', command);
          resolve();
        },
        fail: (err) => {
          console.error('发送指令失败', err);
          if (err.errCode === 10000) {
            console.error('错误原因：未初始化蓝牙适配器');
          } else if (err.errCode === 10001) {
            console.error('错误原因：当前蓝牙适配器不可用');
          } else if (err.errCode === 10002) {
            console.error('错误原因：没有找到指定设备');
          } else if (err.errCode === 10006) {
            console.error('错误原因：当前连接已断开');
          } else if (err.errCode === 10004) {
            console.error('错误原因：没有找到指定服务');
          } else if (err.errCode === 10005) {
            console.error('错误原因：没有找到指定特征');
          } else if (err.errCode === 10007) {
            console.error('错误原因：当前特征不支持此操作');
          } else if (err.errCode === 10013) {
            console.error('错误原因：连接 deviceId 为空或者是格式不正确');
          }
          reject(err);
        }
      });
    });
  }

  // 断开连接
  disconnect() {
    return new Promise((resolve, reject) => {
      if (!this.isConnected) {
        resolve();
        return;
      }

      // 先停止通知
      if (this.notifyCharId) {
        wx.notifyBLECharacteristicValueChange({
          deviceId: this.deviceId,
          serviceId: this.serviceId,
          characteristicId: this.notifyCharId,
          state: false,
          complete: () => {
            // 关闭连接
            this.closeConnection(resolve, reject);
          }
        });
      } else {
        this.closeConnection(resolve, reject);
      }
    });
  }

  // 关闭连接
  closeConnection(resolve, reject) {
    wx.closeBLEConnection({
      deviceId: this.deviceId,
      success: () => {
        console.log('设备断开连接成功');
        this.cleanup();
        resolve();
      },
      fail: (err) => {
        console.error('设备断开连接失败:', err);
        this.cleanup();
        reject(err);
      }
    });
  }

  // 停止搜索
  stopSearch() {
    return new Promise((resolve, reject) => {
      if (!this.isSearching) {
        resolve();
        return;
      }

      // 清除超时定时器
      if (this.searchTimeout) {
        clearTimeout(this.searchTimeout);
        this.searchTimeout = null;
      }

      wx.stopBluetoothDevicesDiscovery({
        success: (res) => {
          console.log('停止搜索成功');
          this.isSearching = false;
          resolve(res);
        },
        fail: (err) => {
          console.error('停止搜索失败:', err);
          this.isSearching = false;
          reject(err);
        }
      });
    });
  }

  // 清理状态
  cleanup() {
    this.isConnected = false;
    this.isSearching = false;
    this.deviceId = null;
    this.serviceId = null;
    this.notifyCharId = null;
    this.writeCharId = null;
    
    // 移除所有监听
    wx.offBluetoothDeviceFound();
    wx.offBLECharacteristicValueChange();
  }
}

module.exports = new BleManager(); 